home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 March / PCWMAR09.iso / Software / Freeware / Adobe Media Player 1.6 / adobe_media_player.air / AMP.swf / scripts / mx / controls / NavBar.as < prev    next >
Encoding:
Text File  |  2008-11-25  |  19.5 KB  |  630 lines
  1. package mx.controls
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.InteractiveObject;
  5.    import flash.events.Event;
  6.    import flash.events.MouseEvent;
  7.    import mx.collections.ArrayCollection;
  8.    import mx.collections.IList;
  9.    import mx.containers.Box;
  10.    import mx.containers.BoxDirection;
  11.    import mx.containers.ViewStack;
  12.    import mx.core.ClassFactory;
  13.    import mx.core.Container;
  14.    import mx.core.FlexVersion;
  15.    import mx.core.IFactory;
  16.    import mx.core.IFlexDisplayObject;
  17.    import mx.core.ScrollPolicy;
  18.    import mx.core.UIComponent;
  19.    import mx.core.mx_internal;
  20.    import mx.events.ChildExistenceChangedEvent;
  21.    import mx.events.CollectionEvent;
  22.    import mx.events.FlexEvent;
  23.    import mx.events.IndexChangedEvent;
  24.    import mx.events.ItemClickEvent;
  25.    
  26.    use namespace mx_internal;
  27.    
  28.    public class NavBar extends Box
  29.    {
  30.       mx_internal static const VERSION:String = "3.2.0.3958";
  31.       
  32.       private var _labelField:String = "label";
  33.       
  34.       private var _iconField:String = "icon";
  35.       
  36.       private var _dataProvider:IList;
  37.       
  38.       private var measurementHasBeenCalled:Boolean = false;
  39.       
  40.       private var _toolTipField:String = "toolTip";
  41.       
  42.       mx_internal var navItemFactory:IFactory;
  43.       
  44.       private var pendingTargetStack:Object;
  45.       
  46.       private var lastToolTip:String = null;
  47.       
  48.       private var _labelFunction:Function;
  49.       
  50.       mx_internal var targetStack:ViewStack;
  51.       
  52.       private var _selectedIndex:int = -1;
  53.       
  54.       private var dataProviderChanged:Boolean = false;
  55.       
  56.       public function NavBar()
  57.       {
  58.          mx_internal::navItemFactory = new ClassFactory(Button);
  59.          super();
  60.          direction = BoxDirection.HORIZONTAL;
  61.          showInAutomationHierarchy = true;
  62.       }
  63.       
  64.       [Bindable("iconFieldChanged")]
  65.       public function get iconField() : String
  66.       {
  67.          return _iconField;
  68.       }
  69.       
  70.       override public function set enabled(param1:Boolean) : void
  71.       {
  72.          var _loc2_:int = 0;
  73.          var _loc3_:int = 0;
  74.          if(param1 != enabled)
  75.          {
  76.             super.enabled = param1;
  77.             _loc2_ = numChildren;
  78.             _loc3_ = 0;
  79.             while(_loc3_ < _loc2_)
  80.             {
  81.                if(mx_internal::targetStack)
  82.                {
  83.                   Button(getChildAt(_loc3_)).enabled = param1 && Container(mx_internal::targetStack.getChildAt(_loc3_)).enabled;
  84.                }
  85.                else
  86.                {
  87.                   Button(getChildAt(_loc3_)).enabled = param1;
  88.                }
  89.                _loc3_++;
  90.             }
  91.          }
  92.       }
  93.       
  94.       protected function updateNavItemIcon(param1:int, param2:Class) : void
  95.       {
  96.          var _loc3_:Button = Button(getChildAt(param1));
  97.          _loc3_.setStyle("icon",param2);
  98.       }
  99.       
  100.       private function childIndexChangeHandler(param1:IndexChangedEvent) : void
  101.       {
  102.          if(param1.target == this)
  103.          {
  104.             return;
  105.          }
  106.          setChildIndex(getChildAt(param1.oldIndex),param1.newIndex);
  107.          resetNavItems();
  108.       }
  109.       
  110.       protected function hiliteSelectedNavItem(param1:int) : void
  111.       {
  112.       }
  113.       
  114.       private function checkPendingTargetStack() : void
  115.       {
  116.          if(pendingTargetStack)
  117.          {
  118.             _setTargetViewStack(pendingTargetStack);
  119.             pendingTargetStack = null;
  120.          }
  121.       }
  122.       
  123.       private function setTargetViewStack(param1:Object) : void
  124.       {
  125.          if(!measurementHasBeenCalled && Boolean(param1))
  126.          {
  127.             pendingTargetStack = param1;
  128.             invalidateProperties();
  129.          }
  130.          else
  131.          {
  132.             _setTargetViewStack(param1);
  133.          }
  134.       }
  135.       
  136.       override public function get baselinePosition() : Number
  137.       {
  138.          if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  139.          {
  140.             return super.baselinePosition;
  141.          }
  142.          if(!mx_internal::validateBaselinePosition())
  143.          {
  144.             return NaN;
  145.          }
  146.          if(numChildren == 0)
  147.          {
  148.             return super.baselinePosition;
  149.          }
  150.          var _loc1_:Button = Button(getChildAt(0));
  151.          validateNow();
  152.          return _loc1_.y + _loc1_.baselinePosition;
  153.       }
  154.       
  155.       private function enabledChangedHandler(param1:Event) : void
  156.       {
  157.          var _loc2_:int = mx_internal::targetStack.getChildIndex(DisplayObject(param1.target));
  158.          Button(getChildAt(_loc2_)).enabled = enabled && Boolean(param1.target.enabled);
  159.       }
  160.       
  161.       private function labelChangedHandler(param1:Event) : void
  162.       {
  163.          var _loc2_:int = mx_internal::targetStack.getChildIndex(DisplayObject(param1.target));
  164.          updateNavItemLabel(_loc2_,Container(param1.target).label);
  165.       }
  166.       
  167.       override protected function createChildren() : void
  168.       {
  169.          super.createChildren();
  170.          if(dataProviderChanged)
  171.          {
  172.             createNavChildren();
  173.             dataProviderChanged = false;
  174.          }
  175.       }
  176.       
  177.       override public function notifyStyleChangeInChildren(param1:String, param2:Boolean) : void
  178.       {
  179.          super.notifyStyleChangeInChildren(param1,true);
  180.       }
  181.       
  182.       protected function clickHandler(param1:MouseEvent) : void
  183.       {
  184.          var _loc2_:int = getChildIndex(DisplayObject(param1.currentTarget));
  185.          if(mx_internal::targetStack)
  186.          {
  187.             mx_internal::targetStack.selectedIndex = _loc2_;
  188.          }
  189.          _selectedIndex = _loc2_;
  190.          var _loc3_:ItemClickEvent = new ItemClickEvent(ItemClickEvent.ITEM_CLICK);
  191.          _loc3_.label = Button(param1.currentTarget).label;
  192.          _loc3_.index = _loc2_;
  193.          _loc3_.relatedObject = InteractiveObject(param1.currentTarget);
  194.          _loc3_.item = !!_dataProvider ? _dataProvider.getItemAt(_loc2_) : null;
  195.          dispatchEvent(_loc3_);
  196.          param1.stopImmediatePropagation();
  197.       }
  198.       
  199.       override public function get horizontalScrollPolicy() : String
  200.       {
  201.          return ScrollPolicy.OFF;
  202.       }
  203.       
  204.       public function set iconField(param1:String) : void
  205.       {
  206.          _iconField = param1;
  207.          if(_dataProvider)
  208.          {
  209.             dataProvider = _dataProvider;
  210.          }
  211.          dispatchEvent(new Event("iconFieldChanged"));
  212.       }
  213.       
  214.       private function childAddHandler(param1:ChildExistenceChangedEvent) : void
  215.       {
  216.          if(param1.target == this)
  217.          {
  218.             return;
  219.          }
  220.          if(param1.relatedObject.parent != mx_internal::targetStack)
  221.          {
  222.             return;
  223.          }
  224.          var _loc2_:Container = Container(param1.relatedObject);
  225.          var _loc3_:Button = Button(createNavItem(itemToLabel(_loc2_),_loc2_.icon));
  226.          var _loc4_:int = _loc2_.parent.getChildIndex(DisplayObject(_loc2_));
  227.          setChildIndex(_loc3_,_loc4_);
  228.          if(_loc2_.toolTip)
  229.          {
  230.             _loc3_.toolTip = _loc2_.toolTip;
  231.             _loc2_.toolTip = null;
  232.          }
  233.          _loc2_.addEventListener("labelChanged",labelChangedHandler);
  234.          _loc2_.addEventListener("iconChanged",iconChangedHandler);
  235.          _loc2_.addEventListener("enabledChanged",enabledChangedHandler);
  236.          _loc2_.addEventListener("toolTipChanged",toolTipChangedHandler);
  237.          _loc3_.enabled = enabled && _loc2_.enabled;
  238.       }
  239.       
  240.       public function itemToLabel(param1:Object) : String
  241.       {
  242.          var data:Object = param1;
  243.          if(data == null)
  244.          {
  245.             return "";
  246.          }
  247.          if(labelFunction != null)
  248.          {
  249.             return labelFunction(data);
  250.          }
  251.          if(data is XML)
  252.          {
  253.             try
  254.             {
  255.                if(data[labelField].length() != 0)
  256.                {
  257.                   data = data[labelField];
  258.                }
  259.             }
  260.             catch(e:Error)
  261.             {
  262.             }
  263.          }
  264.          else if(data is Object)
  265.          {
  266.             try
  267.             {
  268.                if(data[labelField] != null)
  269.                {
  270.                   data = data[labelField];
  271.                }
  272.             }
  273.             catch(e:Error)
  274.             {
  275.             }
  276.          }
  277.          if(data is String)
  278.          {
  279.             return String(data);
  280.          }
  281.          if(data is Number)
  282.          {
  283.             return data.toString();
  284.          }
  285.          return "";
  286.       }
  287.       
  288.       private function createNavChildren() : void
  289.       {
  290.          var i:int;
  291.          var n:int;
  292.          var item:Object = null;
  293.          var navItem:Button = null;
  294.          var label:String = null;
  295.          var iconValue:Object = null;
  296.          var icon:Class = null;
  297.          if(!_dataProvider)
  298.          {
  299.             return;
  300.          }
  301.          n = _dataProvider.length;
  302.          i = 0;
  303.          for(; i < n; navItem.enabled = enabled,i++)
  304.          {
  305.             item = _dataProvider.getItemAt(i);
  306.             if(item is String)
  307.             {
  308.                navItem = Button(createNavItem(String(item)));
  309.             }
  310.             else
  311.             {
  312.                label = itemToLabel(item);
  313.                if(iconField)
  314.                {
  315.                   iconValue = null;
  316.                   try
  317.                   {
  318.                      iconValue = item[iconField];
  319.                   }
  320.                   catch(e:Error)
  321.                   {
  322.                   }
  323.                   icon = iconValue is String ? Class(systemManager.getDefinitionByName(String(iconValue))) : Class(iconValue);
  324.                   navItem = Button(createNavItem(label,icon));
  325.                }
  326.                else
  327.                {
  328.                   navItem = Button(createNavItem(label,null));
  329.                }
  330.                if(toolTipField)
  331.                {
  332.                   try
  333.                   {
  334.                      navItem.toolTip = item[toolTipField] === undefined ? null : item[toolTipField];
  335.                   }
  336.                   catch(e:Error)
  337.                   {
  338.                   }
  339.                   continue;
  340.                }
  341.             }
  342.          }
  343.       }
  344.       
  345.       public function set toolTipField(param1:String) : void
  346.       {
  347.          _toolTipField = param1;
  348.          if(_dataProvider)
  349.          {
  350.             dataProvider = _dataProvider;
  351.          }
  352.          dispatchEvent(new Event("toolTipFieldChanged"));
  353.       }
  354.       
  355.       private function _setTargetViewStack(param1:Object) : void
  356.       {
  357.          var _loc2_:ViewStack = null;
  358.          var _loc6_:Container = null;
  359.          var _loc7_:Button = null;
  360.          if(param1 is ViewStack)
  361.          {
  362.             _loc2_ = ViewStack(param1);
  363.          }
  364.          else if(param1)
  365.          {
  366.             _loc2_ = parentDocument[param1];
  367.          }
  368.          else
  369.          {
  370.             _loc2_ = null;
  371.          }
  372.          if(mx_internal::targetStack)
  373.          {
  374.             mx_internal::targetStack.removeEventListener(ChildExistenceChangedEvent.CHILD_ADD,childAddHandler);
  375.             mx_internal::targetStack.removeEventListener(ChildExistenceChangedEvent.CHILD_REMOVE,childRemoveHandler);
  376.             mx_internal::targetStack.removeEventListener(Event.CHANGE,changeHandler);
  377.             mx_internal::targetStack.removeEventListener(IndexChangedEvent.CHILD_INDEX_CHANGE,childIndexChangeHandler);
  378.          }
  379.          removeAllChildren();
  380.          _selectedIndex = -1;
  381.          mx_internal::targetStack = _loc2_;
  382.          if(!mx_internal::targetStack)
  383.          {
  384.             return;
  385.          }
  386.          mx_internal::targetStack.addEventListener(ChildExistenceChangedEvent.CHILD_ADD,childAddHandler);
  387.          mx_internal::targetStack.addEventListener(ChildExistenceChangedEvent.CHILD_REMOVE,childRemoveHandler);
  388.          mx_internal::targetStack.addEventListener(Event.CHANGE,changeHandler);
  389.          mx_internal::targetStack.addEventListener(IndexChangedEvent.CHILD_INDEX_CHANGE,childIndexChangeHandler);
  390.          var _loc3_:int = mx_internal::targetStack.numChildren;
  391.          var _loc4_:int = 0;
  392.          while(_loc4_ < _loc3_)
  393.          {
  394.             _loc6_ = Container(mx_internal::targetStack.getChildAt(_loc4_));
  395.             _loc7_ = Button(createNavItem(itemToLabel(_loc6_),_loc6_.icon));
  396.             if(_loc6_.toolTip)
  397.             {
  398.                _loc7_.toolTip = _loc6_.toolTip;
  399.                _loc6_.toolTip = null;
  400.             }
  401.             _loc6_.addEventListener("labelChanged",labelChangedHandler);
  402.             _loc6_.addEventListener("iconChanged",iconChangedHandler);
  403.             _loc6_.addEventListener("enabledChanged",enabledChangedHandler);
  404.             _loc6_.addEventListener("toolTipChanged",toolTipChangedHandler);
  405.             _loc7_.enabled = enabled && _loc6_.enabled;
  406.             _loc4_++;
  407.          }
  408.          var _loc5_:int = mx_internal::targetStack.selectedIndex;
  409.          if(_loc5_ == -1 && mx_internal::targetStack.numChildren > 0)
  410.          {
  411.             _loc5_ = 0;
  412.          }
  413.          if(_loc5_ != -1)
  414.          {
  415.             hiliteSelectedNavItem(_loc5_);
  416.          }
  417.          invalidateDisplayList();
  418.       }
  419.       
  420.       private function toolTipChangedHandler(param1:Event) : void
  421.       {
  422.          var _loc2_:int = mx_internal::targetStack.getChildIndex(DisplayObject(param1.target));
  423.          var _loc3_:UIComponent = UIComponent(getChildAt(_loc2_));
  424.          if(UIComponent(param1.target).toolTip)
  425.          {
  426.             _loc3_.toolTip = UIComponent(param1.target).toolTip;
  427.             lastToolTip = UIComponent(param1.target).toolTip;
  428.             UIComponent(param1.target).toolTip = null;
  429.          }
  430.          else if(!lastToolTip)
  431.          {
  432.             _loc3_.toolTip = UIComponent(param1.target).toolTip;
  433.             lastToolTip = "placeholder";
  434.             UIComponent(param1.target).toolTip = null;
  435.          }
  436.          else
  437.          {
  438.             lastToolTip = null;
  439.          }
  440.       }
  441.       
  442.       protected function createNavItem(param1:String, param2:Class = null) : IFlexDisplayObject
  443.       {
  444.          return null;
  445.       }
  446.       
  447.       [Bindable("collectionChange")]
  448.       public function get dataProvider() : Object
  449.       {
  450.          return !!mx_internal::targetStack ? mx_internal::targetStack : _dataProvider;
  451.       }
  452.       
  453.       protected function updateNavItemLabel(param1:int, param2:String) : void
  454.       {
  455.          var _loc3_:Button = Button(getChildAt(param1));
  456.          _loc3_.label = param2;
  457.       }
  458.       
  459.       override public function set horizontalScrollPolicy(param1:String) : void
  460.       {
  461.       }
  462.       
  463.       override protected function commitProperties() : void
  464.       {
  465.          super.commitProperties();
  466.          if(!measurementHasBeenCalled)
  467.          {
  468.             checkPendingTargetStack();
  469.             measurementHasBeenCalled = true;
  470.          }
  471.          if(dataProviderChanged)
  472.          {
  473.             dataProviderChanged = false;
  474.             createNavChildren();
  475.          }
  476.          if(mx_internal::blocker)
  477.          {
  478.             mx_internal::blocker.visible = false;
  479.          }
  480.       }
  481.       
  482.       public function set labelField(param1:String) : void
  483.       {
  484.          _labelField = param1;
  485.          if(_dataProvider)
  486.          {
  487.             dataProvider = _dataProvider;
  488.          }
  489.          dispatchEvent(new Event("labelFieldChanged"));
  490.       }
  491.       
  492.       private function iconChangedHandler(param1:Event) : void
  493.       {
  494.          var _loc2_:int = mx_internal::targetStack.getChildIndex(DisplayObject(param1.target));
  495.          updateNavItemIcon(_loc2_,Container(param1.target).icon);
  496.       }
  497.       
  498.       protected function resetNavItems() : void
  499.       {
  500.       }
  501.       
  502.       [Bindable("toolTipFieldChanged")]
  503.       public function get toolTipField() : String
  504.       {
  505.          return _toolTipField;
  506.       }
  507.       
  508.       public function set labelFunction(param1:Function) : void
  509.       {
  510.          _labelFunction = param1;
  511.          invalidateDisplayList();
  512.          dispatchEvent(new Event("labelFunctionChanged"));
  513.       }
  514.       
  515.       [Bindable("labelFieldChanged")]
  516.       public function get labelField() : String
  517.       {
  518.          return _labelField;
  519.       }
  520.       
  521.       override public function set verticalScrollPolicy(param1:String) : void
  522.       {
  523.       }
  524.       
  525.       private function childRemoveHandler(param1:ChildExistenceChangedEvent) : void
  526.       {
  527.          if(param1.target == this)
  528.          {
  529.             return;
  530.          }
  531.          var _loc2_:ViewStack = ViewStack(param1.target);
  532.          removeChildAt(_loc2_.getChildIndex(param1.relatedObject));
  533.          callLater(resetNavItems);
  534.       }
  535.       
  536.       [Bindable("labelFunctionChanged")]
  537.       public function get labelFunction() : Function
  538.       {
  539.          return _labelFunction;
  540.       }
  541.       
  542.       override public function get verticalScrollPolicy() : String
  543.       {
  544.          return ScrollPolicy.OFF;
  545.       }
  546.       
  547.       public function set dataProvider(param1:Object) : void
  548.       {
  549.          var _loc2_:String = null;
  550.          var _loc3_:String = null;
  551.          if(param1 && !(param1 is String) && !(param1 is ViewStack) && !(param1 is Array) && !(param1 is IList))
  552.          {
  553.             _loc2_ = resourceManager.getString("controls","errWrongContainer",[id]);
  554.             throw new Error(_loc2_);
  555.          }
  556.          if(param1 is String && (document && document[param1]))
  557.          {
  558.             param1 = document[param1];
  559.          }
  560.          if(param1 is String || param1 is ViewStack)
  561.          {
  562.             setTargetViewStack(param1);
  563.             return;
  564.          }
  565.          if(param1 is IList && IList(param1).length > 0 && IList(param1).getItemAt(0) is DisplayObject || param1 is Array && (param1 as Array).length > 0 && param1[0] is DisplayObject)
  566.          {
  567.             _loc3_ = !!id ? className + " \'" + id + "\'" : "a " + className;
  568.             _loc2_ = resourceManager.getString("controls","errWrongType",[_loc3_]);
  569.             throw new Error(_loc2_);
  570.          }
  571.          setTargetViewStack(null);
  572.          removeAllChildren();
  573.          if(param1 is IList)
  574.          {
  575.             _dataProvider = IList(param1);
  576.          }
  577.          else if(param1 is Array)
  578.          {
  579.             _dataProvider = new ArrayCollection(param1 as Array);
  580.          }
  581.          else
  582.          {
  583.             _dataProvider = null;
  584.          }
  585.          dataProviderChanged = true;
  586.          invalidateProperties();
  587.          if(_dataProvider)
  588.          {
  589.             _dataProvider.addEventListener(CollectionEvent.COLLECTION_CHANGE,collectionChangeHandler,false,0,true);
  590.          }
  591.          if(inheritingStyles == UIComponent.mx_internal::STYLE_UNINITIALIZED)
  592.          {
  593.             return;
  594.          }
  595.          dispatchEvent(new Event("collectionChange"));
  596.       }
  597.       
  598.       private function changeHandler(param1:Event) : void
  599.       {
  600.          if(param1.target == dataProvider)
  601.          {
  602.             hiliteSelectedNavItem(Object(param1.target).selectedIndex);
  603.          }
  604.       }
  605.       
  606.       private function collectionChangeHandler(param1:Event) : void
  607.       {
  608.          dataProvider = dataProvider;
  609.       }
  610.       
  611.       public function set selectedIndex(param1:int) : void
  612.       {
  613.          _selectedIndex = param1;
  614.          if(mx_internal::targetStack)
  615.          {
  616.             mx_internal::targetStack.selectedIndex = param1;
  617.          }
  618.          dispatchEvent(new FlexEvent(FlexEvent.VALUE_COMMIT));
  619.       }
  620.       
  621.       [Bindable("valueCommit")]
  622.       [Bindable("itemClick")]
  623.       public function get selectedIndex() : int
  624.       {
  625.          return _selectedIndex;
  626.       }
  627.    }
  628. }
  629.  
  630.